/**
 * 用户数据管理工具
 * 基于用户ID实现单用户的数据隔离和管理
 */

import { getUserInfo } from '@/utils/auth'

/**
 * 获取当前用户ID
 */
export function getCurrentUserId(): string | null {
  try {
    const userInfo = getUserInfo()
    if (!userInfo) {
      console.warn('⚠️ 未找到用户信息')
      return null
    }
    
    const userId = userInfo.id || userInfo.userId
    if (!userId) {
      console.warn('⚠️ 用户信息中缺少ID字段')
      return null
    }
    
    return String(userId)
  } catch (error) {
    console.error('❌ 获取用户ID失败:', error)
    return null
  }
}

/**
 * 获取用户专属的存储键名
 * @param feature 功能名称 (如: 'knowledgeQA', 'translation', 'textGeneration' 等)
 * @param dataType 数据类型 (如: 'history', 'settings', 'favorites' 等)
 */
export function getUserStorageKey(feature: string, dataType: string): string | null {
  const userId = getCurrentUserId()
  if (!userId) {
    return null
  }
  
  return `ai_${feature}_${dataType}_user_${userId}`
}

/**
 * 保存用户数据到localStorage
 * @param feature 功能名称
 * @param dataType 数据类型
 * @param data 要保存的数据
 */
export function saveUserData(feature: string, dataType: string, data: any): boolean {
  try {
    const key = getUserStorageKey(feature, dataType)
    if (!key) {
      console.warn('⚠️ 无法生成存储键名，用户未登录')
      return false
    }
    
    localStorage.setItem(key, JSON.stringify(data))
    console.log(`✅ 用户数据已保存: ${feature}.${dataType}`)
    return true
  } catch (error) {
    console.error('❌ 保存用户数据失败:', error)
    return false
  }
}

/**
 * 从localStorage加载用户数据
 * @param feature 功能名称
 * @param dataType 数据类型
 * @param defaultValue 默认值
 */
export function loadUserData<T>(feature: string, dataType: string, defaultValue: T): T {
  try {
    const key = getUserStorageKey(feature, dataType)
    if (!key) {
      console.warn('⚠️ 无法生成存储键名，用户未登录，返回默认值')
      return defaultValue
    }
    
    const stored = localStorage.getItem(key)
    if (!stored) {
      console.log(`📝 用户数据不存在: ${feature}.${dataType}，返回默认值`)
      return defaultValue
    }
    
    const parsed = JSON.parse(stored)
    console.log(`✅ 用户数据已加载: ${feature}.${dataType}`)
    return parsed
  } catch (error) {
    console.error('❌ 加载用户数据失败:', error)
    return defaultValue
  }
}

/**
 * 删除用户数据
 * @param feature 功能名称
 * @param dataType 数据类型
 */
export function removeUserData(feature: string, dataType: string): boolean {
  try {
    const key = getUserStorageKey(feature, dataType)
    if (!key) {
      console.warn('⚠️ 无法生成存储键名，用户未登录')
      return false
    }
    
    localStorage.removeItem(key)
    console.log(`🗑️ 用户数据已删除: ${feature}.${dataType}`)
    return true
  } catch (error) {
    console.error('❌ 删除用户数据失败:', error)
    return false
  }
}

/**
 * 清空指定功能的所有用户数据
 * @param feature 功能名称
 */
export function clearFeatureData(feature: string): boolean {
  try {
    const userId = getCurrentUserId()
    if (!userId) {
      console.warn('⚠️ 用户未登录，无法清空数据')
      return false
    }
    
    const prefix = `ai_${feature}_`
    const suffix = `_user_${userId}`
    
    // 遍历localStorage，删除匹配的键
    const keysToRemove: string[] = []
    for (let i = 0; i < localStorage.length; i++) {
      const key = localStorage.key(i)
      if (key && key.startsWith(prefix) && key.endsWith(suffix)) {
        keysToRemove.push(key)
      }
    }
    
    keysToRemove.forEach(key => localStorage.removeItem(key))
    console.log(`🗑️ 已清空功能数据: ${feature} (${keysToRemove.length}项)`)
    return true
  } catch (error) {
    console.error('❌ 清空功能数据失败:', error)
    return false
  }
}

/**
 * 获取用户的所有数据键名
 */
export function getUserDataKeys(): string[] {
  try {
    const userId = getCurrentUserId()
    if (!userId) {
      return []
    }
    
    const suffix = `_user_${userId}`
    const userKeys: string[] = []
    
    for (let i = 0; i < localStorage.length; i++) {
      const key = localStorage.key(i)
      if (key && key.startsWith('ai_') && key.endsWith(suffix)) {
        userKeys.push(key)
      }
    }
    
    return userKeys
  } catch (error) {
    console.error('❌ 获取用户数据键名失败:', error)
    return []
  }
}

/**
 * 获取用户数据统计信息
 */
export function getUserDataStats(): {
  totalKeys: number
  features: string[]
  dataTypes: string[]
  totalSize: number
} {
  try {
    const userKeys = getUserDataKeys()
    const features = new Set<string>()
    const dataTypes = new Set<string>()
    let totalSize = 0
    
    userKeys.forEach(key => {
      // 解析键名格式: ai_{feature}_{dataType}_user_{userId}
      const parts = key.split('_')
      if (parts.length >= 4) {
        const feature = parts[1]
        const dataType = parts[2]
        features.add(feature)
        dataTypes.add(dataType)
        
        // 计算数据大小
        const data = localStorage.getItem(key)
        if (data) {
          totalSize += data.length
        }
      }
    })
    
    return {
      totalKeys: userKeys.length,
      features: Array.from(features),
      dataTypes: Array.from(dataTypes),
      totalSize
    }
  } catch (error) {
    console.error('❌ 获取用户数据统计失败:', error)
    return {
      totalKeys: 0,
      features: [],
      dataTypes: [],
      totalSize: 0
    }
  }
}

/**
 * 迁移旧的localStorage数据到新的用户隔离格式
 * @param feature 功能名称
 * @param oldKeys 旧的键名数组
 */
export function migrateOldData(feature: string, oldKeys: { oldKey: string, dataType: string }[]): boolean {
  try {
    const userId = getCurrentUserId()
    if (!userId) {
      console.warn('⚠️ 用户未登录，无法迁移数据')
      return false
    }
    
    let migratedCount = 0
    
    oldKeys.forEach(({ oldKey, dataType }) => {
      const oldData = localStorage.getItem(oldKey)
      if (oldData) {
        // 保存到新格式
        const newKey = getUserStorageKey(feature, dataType)
        if (newKey) {
          localStorage.setItem(newKey, oldData)
          localStorage.removeItem(oldKey) // 删除旧数据
          migratedCount++
          console.log(`📦 已迁移数据: ${oldKey} -> ${newKey}`)
        }
      }
    })
    
    if (migratedCount > 0) {
      console.log(`✅ 数据迁移完成: ${feature} (${migratedCount}项)`)
    }
    
    return true
  } catch (error) {
    console.error('❌ 数据迁移失败:', error)
    return false
  }
}

/**
 * 格式化数据大小
 */
export function formatDataSize(bytes: number): string {
  if (bytes === 0) return '0 B'
  
  const k = 1024
  const sizes = ['B', 'KB', 'MB', 'GB']
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
}
